﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using ZP.Common;
using ZP.DTO.ep_base_info;
using ZP.DTO.ep_basic_data;
using ZP.DTO.ep_investor;
using ZP.DTO.ht_honor_title;
using ZP.IBLL;
using ZP.IDAL;
using ZP.Model;
using Z.EntityFramework.Plus;
using ZP.DTO.ep_business_product;

namespace ZP.BLL
{
    public class ep_base_infoService : BaseService<ep_base_info, int>, Iep_base_infoService
    {

        public ep_base_infoResultDTO GetEnterprise(int ep_id)
        {
            var psie = (ZPJ_Entities)_repository.GetDbContext();
            var iquery = psie.ep_base_info.Include("ep_cert_qualified").Include("ep_ip_info").Include("ep_personnel_stats").Include("ep_product_info").Where(p => p.ep_id == ep_id);
            //var iquery = psie.ep_base_info.Include("ep_cert_qualified").Include("ep_ip_info").Include("ep_product_info").Where(p => p.ep_id == ep_id);
            //序列化类型为“System.Data.Entity.DynamicProxies.xxxx”的对象时检测到循环引用。 加上这个就OK了
            psie.Configuration.ProxyCreationEnabled = false;
            var dto = AutoMapper.Mapper.Map<ep_base_infoResultDTO>(iquery.FirstOrDefault());

            if (dto != null)
            {
                //获得ep_basic_data数据 获得最近三年的数据
                var current_year = DateTime.Now.Year;
                var lastThreeYear = new List<int> { current_year - 3, current_year - 2, current_year - 1 };

                List<ep_basic_dataResultDTO> ep_basic_dataDTOList = new List<ep_basic_dataResultDTO>();
                ep_basic_dataResultDTO ep_basic_dataDTO = null;
                ep_basic_data ep_basic_data = null;
                foreach (var year in lastThreeYear)
                {
                    ep_basic_data = psie.ep_basic_data.AsNoTracking().Where(p => p.ep_id == ep_id && p.data_year == year).FirstOrDefault();
                    ep_basic_dataDTO = ep_basic_data == null ? (new ep_basic_dataResultDTO { data_year = (short)year }) : AutoMapper.Mapper.Map<ep_basic_dataResultDTO>(ep_basic_data);
                    ep_basic_dataDTOList.Add(ep_basic_dataDTO);
                }
                dto.ep_basic_data = ep_basic_dataDTOList;
            }
            return dto;
        }


        public List<EnterpriseHonorScoreResultDTO> GetEnterpriseZPJScore(int ep_id)
        {
            var psie = (ZPJ_Entities)_repository.GetDbContext();

            //获得所有荣誉 根据每个荣誉类型以及是否 来获得数量、内容、附件
            //类型为数量或者内容
            var iquery1 = from ht in psie.ht_honor_title
                          join eh in psie.ep_ht on ht.ht_id equals eh.ht_id
                          where eh.ep_id == ep_id && eh.ht_is.HasValue && eh.ht_is.Value
                          select new EnterpriseHonorScoreResultDTO
                          {
                              ht_title = ht.ht_title,
                              ht_type = ht.ht_type.HasValue ? ht.ht_type.Value : (byte)ZPFlagType.NO,
                              //score = ht_type
                          };

            return null;
        }

        public bool SaveEnterprise(ep_base_infoOperateDTO dto)
        {
            bool result = false;
            try
            {
                //单位基本信息
                if (dto.submitType == 1)
                {
                    ep_base_info updateEntity = AutoMapper.Mapper.Map<ep_base_info>(dto);
                    if (_repository.GetModels(p => p.ep_id == dto.ep_id).Any())
                    {
                        _repository.Update(updateEntity);
                    }
                    else
                    {
                        _repository.Add(updateEntity);
                    }
                    #region 主要股东/出资人信息
                    List<ep_investor> ep_investorAdd = AutoMapper.Mapper.Map<List<ep_investor>>(dto.ep_investor);
                    //先清除
                    _ep_investorDAL.GetModels(p => p.ep_id == dto.ep_id).Delete();
                    //保存-主要股东/出资人信息
                    if (dto.ep_investor != null && dto.ep_investor.Count > 0)
                    {
                        ep_investorAdd = AutoMapper.Mapper.Map<List<ep_investor>>(dto.ep_investor);
                        //再添加
                        ep_investorAdd.ForEach(s =>
                        {
                            s.id = Guid.NewGuid();
                            s.ep_id = dto.ep_id;
                            _ep_investorDAL.Add(s, false);
                        });
                    }
                    _ep_investorDAL.SaveChanges();
                    #endregion
                }
                //人员基本信息
                else if (dto.submitType == 2)
                {
                    ep_personnel_stats updateEntity = AutoMapper.Mapper.Map<ep_personnel_stats>(dto.ep_personnel_stats);
                    updateEntity.ep_id = dto.ep_id;
                    if (_ep_personnel_statsDAL.GetModels(p => p.ep_id == dto.ep_id).Any())
                    {
                        _ep_personnel_statsDAL.Update(updateEntity);
                    }
                    else
                    {
                        _ep_personnel_statsDAL.Add(updateEntity);
                    }
                    #region 人员基本信息-列表
                    List<ep_personnel_info> ep_personnel_infoAdd = AutoMapper.Mapper.Map<List<ep_personnel_info>>(dto.ep_personnel_info);
                    //先清除
                    _ep_personnel_infoDAL.GetModels(p => p.ep_id == dto.ep_id).Delete();
                    //保存-主要股东/出资人信息
                    if (dto.ep_personnel_info != null && dto.ep_personnel_info.Count > 0)
                    {
                        ep_personnel_infoAdd = AutoMapper.Mapper.Map<List<ep_personnel_info>>(dto.ep_personnel_info);
                        //再添加
                        ep_personnel_infoAdd.ForEach(s =>
                        {
                            s.id = Guid.NewGuid();
                            s.ep_id = dto.ep_id;
                            _ep_personnel_infoDAL.Add(s, false);
                        });
                    }
                    _ep_personnel_infoDAL.SaveChanges();
                    #endregion
                }
                //单位经济效益
                else if (dto.submitType == 3)
                {

                }
                //知识产权状况
                else if (dto.submitType == 4)
                {

                }
                //政府资助情况
                else if (dto.submitType == 5)
                {
                    #region 政府资助情况
                    List<ep_gov_support> ep_gov_supportAdd = AutoMapper.Mapper.Map<List<ep_gov_support>>(dto.ep_gov_support);
                    //先清除
                    _ep_gov_supportDAL.GetModels(p => p.ep_id == dto.ep_id).Delete();
                    //保存-主要股东/出资人信息
                    if (dto.ep_gov_support != null && dto.ep_gov_support.Count > 0)
                    {
                        ep_gov_supportAdd = AutoMapper.Mapper.Map<List<ep_gov_support>>(dto.ep_gov_support);
                        //再添加
                        var i = 1;
                        ep_gov_supportAdd.ForEach(s =>
                        {
                            s.id = Guid.NewGuid();
                            s.ep_id = dto.ep_id;
                            s.sort = i;
                            i++;
                            _ep_gov_supportDAL.Add(s, false);
                        });
                    }
                    _ep_gov_supportDAL.SaveChanges();
                    #endregion
                }
                //主营业务产品
                else if (dto.submitType == 6)
                {
                    List<ep_business_product> ep_business_productAdd = AutoMapper.Mapper.Map<List<ep_business_product>>(dto.ep_business_product);
                    //先清除
                    _ep_business_productDAL.GetModels(p => p.ep_id == dto.ep_id).Delete();
                    //再添加
                    var i = 1;
                    ep_business_productAdd.ForEach(s =>
                    {
                        s.id = Guid.NewGuid();
                        s.ep_id = dto.ep_id;
                        s.sort = i;
                        i++;
                        _ep_business_productDAL.Add(s, false);
                    });
                    _ep_business_productDAL.SaveChanges();
                }
                #region 主营业务产品 Old
                //if (dto.ep_product_info != null)
                //{
                //    ep_product_info updateEntity = AutoMapper.Mapper.Map<ep_product_info>(dto.ep_product_info);
                //    updateEntity.ep_id = dto.ep_id;
                //    if (_ep_product_infoDAL.GetModels(p => p.ep_id == dto.ep_id).Any())
                //    {
                //        _ep_product_infoDAL.Update(updateEntity);
                //    }
                //    else
                //    {
                //        _ep_product_infoDAL.Add(updateEntity);
                //    }
                //}
                #endregion
                //附件信息
                else if (dto.submitType == 5)
                {

                }

                else if (dto.ep_personnel_stats != null)
                {

                }
                else if (dto.ep_basic_data != null && dto.ep_basic_data.Count > 0)
                {
                    List<ep_basic_data> updateEntity = AutoMapper.Mapper.Map<List<ep_basic_data>>(dto.ep_basic_data);
                    updateEntity.ForEach(s =>
                    {
                        s.ep_id = dto.ep_id;
                        if (s.id == Guid.Empty)
                        {
                            s.id = Guid.NewGuid();
                            _ep_basic_dataDAL.Add(s, false);
                        }
                        else
                        {
                            _ep_basic_dataDAL.Update(s, false);
                        }
                    });
                    _ep_basic_dataDAL.SaveChanges();
                }
                else if (dto.ep_ht != null && dto.ep_ht.Count > 0)
                {
                    List<ep_ht> updateEntity = AutoMapper.Mapper.Map<List<ep_ht>>(dto.ep_ht);
                    updateEntity.ForEach(s =>
                    {
                        s.ep_id = dto.ep_id;
                        if (s.id == Guid.Empty)
                        {
                            s.id = Guid.NewGuid();
                            _ep_htDAL.Add(s, false);
                        }
                        else
                        {
                            _ep_htDAL.Update(s, false);
                        }
                    });
                    _ep_htDAL.SaveChanges();
                }
                else if (dto.ep_ip_info != null)
                {
                    ep_ip_info updateEntity = AutoMapper.Mapper.Map<ep_ip_info>(dto.ep_ip_info);
                    updateEntity.ep_id = dto.ep_id;
                    if (_ep_ip_infoDAL.GetModels(p => p.ep_id == dto.ep_id).Any())
                    {
                        _ep_ip_infoDAL.Update(updateEntity);
                    }
                    else
                    {
                        _ep_ip_infoDAL.Add(updateEntity);
                    }
                }
                else if (dto.ep_cert_qualified != null)
                {
                    ep_cert_qualified updateEntity = AutoMapper.Mapper.Map<ep_cert_qualified>(dto.ep_cert_qualified);
                    updateEntity.ep_id = dto.ep_id;
                    if (_ep_cert_qualifiedDAL.GetModels(p => p.ep_id == dto.ep_id).Any())
                    {
                        _ep_cert_qualifiedDAL.Update(updateEntity);
                    }
                    else
                    {
                        _ep_cert_qualifiedDAL.Add(updateEntity);
                    }
                }
                result = true;
            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
            return result;
        }
    }
}
